home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Magazine / Morphos / GCC / lib / gcc-lib / ppc-amigaos / 2.95.1 / sys-include / powerup / ppcpragmas / commodities_pragmas.h < prev    next >
C/C++ Source or Header  |  2000-03-13  |  14KB  |  516 lines
  1. /* Automatically generated header! Do not edit! */
  2.  
  3. #ifndef _PPCPRAGMA_COMMODITIES_H
  4. #define _PPCPRAGMA_COMMODITIES_H
  5. #ifdef __GNUC__
  6. #ifndef _PPCINLINE__COMMODITIES_H
  7. #include <powerup/ppcinline/commodities.h>
  8. #endif
  9. #else
  10.  
  11. #ifndef POWERUP_PPCLIB_INTERFACE_H
  12. #include <powerup/ppclib/interface.h>
  13. #endif
  14.  
  15. #ifndef POWERUP_GCCLIB_PROTOS_H
  16. #include <powerup/gcclib/powerup_protos.h>
  17. #endif
  18.  
  19. #ifndef NO_PPCINLINE_STDARG
  20. #define NO_PPCINLINE_STDARG
  21. #endif/* SAS C PPC inlines */
  22.  
  23. #ifndef COMMODITIES_BASE_NAME
  24. #define COMMODITIES_BASE_NAME CxBase
  25. #endif /* !COMMODITIES_BASE_NAME */
  26.  
  27. #define    ActivateCxObj(co, tf)    _ActivateCxObj(COMMODITIES_BASE_NAME, co, tf)
  28.  
  29. static __inline LONG
  30. _ActivateCxObj(void *CxBase, CxObj *co, long tf)
  31. {
  32. struct Caos    MyCaos;
  33.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  34. //    MyCaos.M68kStart    =    NULL;
  35. //    MyCaos.M68kSize        =    0;
  36.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  37. //    MyCaos.PPCStart        =    NULL;
  38. //    MyCaos.PPCSize        =    0;
  39.     MyCaos.a0        =(ULONG) co;
  40.     MyCaos.d0        =(ULONG) tf;
  41.     MyCaos.caos_Un.Offset    =    (-42);
  42.     MyCaos.a6        =(ULONG) CxBase;    
  43.     return((LONG)PPCCallOS(&MyCaos));
  44. }
  45.  
  46. #define    AddIEvents(events)    _AddIEvents(COMMODITIES_BASE_NAME, events)
  47.  
  48. static __inline void
  49. _AddIEvents(void *CxBase, struct InputEvent *events)
  50. {
  51. struct Caos    MyCaos;
  52.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  53. //    MyCaos.M68kStart    =    NULL;
  54. //    MyCaos.M68kSize        =    0;
  55.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  56. //    MyCaos.PPCStart        =    NULL;
  57. //    MyCaos.PPCSize        =    0;
  58.     MyCaos.a0        =(ULONG) events;
  59.     MyCaos.caos_Un.Offset    =    (-180);
  60.     MyCaos.a6        =(ULONG) CxBase;    
  61.     PPCCallOS(&MyCaos);
  62. }
  63.  
  64. #define    AttachCxObj(headObj, co)    _AttachCxObj(COMMODITIES_BASE_NAME, headObj, co)
  65.  
  66. static __inline void
  67. _AttachCxObj(void *CxBase, CxObj *headObj, CxObj *co)
  68. {
  69. struct Caos    MyCaos;
  70.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  71. //    MyCaos.M68kStart    =    NULL;
  72. //    MyCaos.M68kSize        =    0;
  73.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  74. //    MyCaos.PPCStart        =    NULL;
  75. //    MyCaos.PPCSize        =    0;
  76.     MyCaos.a0        =(ULONG) headObj;
  77.     MyCaos.a1        =(ULONG) co;
  78.     MyCaos.caos_Un.Offset    =    (-84);
  79.     MyCaos.a6        =(ULONG) CxBase;    
  80.     PPCCallOS(&MyCaos);
  81. }
  82.  
  83. #define    ClearCxObjError(co)    _ClearCxObjError(COMMODITIES_BASE_NAME, co)
  84.  
  85. static __inline void
  86. _ClearCxObjError(void *CxBase, CxObj *co)
  87. {
  88. struct Caos    MyCaos;
  89.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  90. //    MyCaos.M68kStart    =    NULL;
  91. //    MyCaos.M68kSize        =    0;
  92.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  93. //    MyCaos.PPCStart        =    NULL;
  94. //    MyCaos.PPCSize        =    0;
  95.     MyCaos.a0        =(ULONG) co;
  96.     MyCaos.caos_Un.Offset    =    (-72);
  97.     MyCaos.a6        =(ULONG) CxBase;    
  98.     PPCCallOS(&MyCaos);
  99. }
  100.  
  101. #define    CreateCxObj(type, arg1, arg2)    _CreateCxObj(COMMODITIES_BASE_NAME, type, arg1, arg2)
  102.  
  103. static __inline CxObj *
  104. _CreateCxObj(void *CxBase, unsigned long type, long arg1, long arg2)
  105. {
  106. struct Caos    MyCaos;
  107.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  108. //    MyCaos.M68kStart    =    NULL;
  109. //    MyCaos.M68kSize        =    0;
  110.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  111. //    MyCaos.PPCStart        =    NULL;
  112. //    MyCaos.PPCSize        =    0;
  113.     MyCaos.d0        =(ULONG) type;
  114.     MyCaos.a0        =(ULONG) arg1;
  115.     MyCaos.a1        =(ULONG) arg2;
  116.     MyCaos.caos_Un.Offset    =    (-30);
  117.     MyCaos.a6        =(ULONG) CxBase;    
  118.     return((CxObj *)PPCCallOS(&MyCaos));
  119. }
  120.  
  121. #define    CxBroker(nb, error)    _CxBroker(COMMODITIES_BASE_NAME, nb, error)
  122.  
  123. static __inline CxObj *
  124. _CxBroker(void *CxBase, struct NewBroker *nb, LONG *error)
  125. {
  126. struct Caos    MyCaos;
  127.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  128. //    MyCaos.M68kStart    =    NULL;
  129. //    MyCaos.M68kSize        =    0;
  130.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  131. //    MyCaos.PPCStart        =    NULL;
  132. //    MyCaos.PPCSize        =    0;
  133.     MyCaos.a0        =(ULONG) nb;
  134.     MyCaos.d0        =(ULONG) error;
  135.     MyCaos.caos_Un.Offset    =    (-36);
  136.     MyCaos.a6        =(ULONG) CxBase;    
  137.     return((CxObj *)PPCCallOS(&MyCaos));
  138. }
  139.  
  140. #define    CxMsgData(cxm)    _CxMsgData(COMMODITIES_BASE_NAME, cxm)
  141.  
  142. static __inline APTR
  143. _CxMsgData(void *CxBase, CxMsg *cxm)
  144. {
  145. struct Caos    MyCaos;
  146.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  147. //    MyCaos.M68kStart    =    NULL;
  148. //    MyCaos.M68kSize        =    0;
  149.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  150. //    MyCaos.PPCStart        =    NULL;
  151. //    MyCaos.PPCSize        =    0;
  152.     MyCaos.a0        =(ULONG) cxm;
  153.     MyCaos.caos_Un.Offset    =    (-144);
  154.     MyCaos.a6        =(ULONG) CxBase;    
  155.     return((APTR)PPCCallOS(&MyCaos));
  156. }
  157.  
  158. #define    CxMsgID(cxm)    _CxMsgID(COMMODITIES_BASE_NAME, cxm)
  159.  
  160. static __inline LONG
  161. _CxMsgID(void *CxBase, CxMsg *cxm)
  162. {
  163. struct Caos    MyCaos;
  164.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  165. //    MyCaos.M68kStart    =    NULL;
  166. //    MyCaos.M68kSize        =    0;
  167.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  168. //    MyCaos.PPCStart        =    NULL;
  169. //    MyCaos.PPCSize        =    0;
  170.     MyCaos.a0        =(ULONG) cxm;
  171.     MyCaos.caos_Un.Offset    =    (-150);
  172.     MyCaos.a6        =(ULONG) CxBase;    
  173.     return((LONG)PPCCallOS(&MyCaos));
  174. }
  175.  
  176. #define    CxMsgType(cxm)    _CxMsgType(COMMODITIES_BASE_NAME, cxm)
  177.  
  178. static __inline ULONG
  179. _CxMsgType(void *CxBase, CxMsg *cxm)
  180. {
  181. struct Caos    MyCaos;
  182.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  183. //    MyCaos.M68kStart    =    NULL;
  184. //    MyCaos.M68kSize        =    0;
  185.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  186. //    MyCaos.PPCStart        =    NULL;
  187. //    MyCaos.PPCSize        =    0;
  188.     MyCaos.a0        =(ULONG) cxm;
  189.     MyCaos.caos_Un.Offset    =    (-138);
  190.     MyCaos.a6        =(ULONG) CxBase;    
  191.     return((ULONG)PPCCallOS(&MyCaos));
  192. }
  193.  
  194. #define    CxObjError(co)    _CxObjError(COMMODITIES_BASE_NAME, co)
  195.  
  196. static __inline LONG
  197. _CxObjError(void *CxBase, CxObj *co)
  198. {
  199. struct Caos    MyCaos;
  200.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  201. //    MyCaos.M68kStart    =    NULL;
  202. //    MyCaos.M68kSize        =    0;
  203.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  204. //    MyCaos.PPCStart        =    NULL;
  205. //    MyCaos.PPCSize        =    0;
  206.     MyCaos.a0        =(ULONG) co;
  207.     MyCaos.caos_Un.Offset    =    (-66);
  208.     MyCaos.a6        =(ULONG) CxBase;    
  209.     return((LONG)PPCCallOS(&MyCaos));
  210. }
  211.  
  212. #define    CxObjType(co)    _CxObjType(COMMODITIES_BASE_NAME, co)
  213.  
  214. static __inline ULONG
  215. _CxObjType(void *CxBase, CxObj *co)
  216. {
  217. struct Caos    MyCaos;
  218.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  219. //    MyCaos.M68kStart    =    NULL;
  220. //    MyCaos.M68kSize        =    0;
  221.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  222. //    MyCaos.PPCStart        =    NULL;
  223. //    MyCaos.PPCSize        =    0;
  224.     MyCaos.a0        =(ULONG) co;
  225.     MyCaos.caos_Un.Offset    =    (-60);
  226.     MyCaos.a6        =(ULONG) CxBase;    
  227.     return((ULONG)PPCCallOS(&MyCaos));
  228. }
  229.  
  230. #define    DeleteCxObj(co)    _DeleteCxObj(COMMODITIES_BASE_NAME, co)
  231.  
  232. static __inline void
  233. _DeleteCxObj(void *CxBase, CxObj *co)
  234. {
  235. struct Caos    MyCaos;
  236.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  237. //    MyCaos.M68kStart    =    NULL;
  238. //    MyCaos.M68kSize        =    0;
  239.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  240. //    MyCaos.PPCStart        =    NULL;
  241. //    MyCaos.PPCSize        =    0;
  242.     MyCaos.a0        =(ULONG) co;
  243.     MyCaos.caos_Un.Offset    =    (-48);
  244.     MyCaos.a6        =(ULONG) CxBase;    
  245.     PPCCallOS(&MyCaos);
  246. }
  247.  
  248. #define    DeleteCxObjAll(co)    _DeleteCxObjAll(COMMODITIES_BASE_NAME, co)
  249.  
  250. static __inline void
  251. _DeleteCxObjAll(void *CxBase, CxObj *co)
  252. {
  253. struct Caos    MyCaos;
  254.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  255. //    MyCaos.M68kStart    =    NULL;
  256. //    MyCaos.M68kSize        =    0;
  257.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  258. //    MyCaos.PPCStart        =    NULL;
  259. //    MyCaos.PPCSize        =    0;
  260.     MyCaos.a0        =(ULONG) co;
  261.     MyCaos.caos_Un.Offset    =    (-54);
  262.     MyCaos.a6        =(ULONG) CxBase;    
  263.     PPCCallOS(&MyCaos);
  264. }
  265.  
  266. #define    DisposeCxMsg(cxm)    _DisposeCxMsg(COMMODITIES_BASE_NAME, cxm)
  267.  
  268. static __inline void
  269. _DisposeCxMsg(void *CxBase, CxMsg *cxm)
  270. {
  271. struct Caos    MyCaos;
  272.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  273. //    MyCaos.M68kStart    =    NULL;
  274. //    MyCaos.M68kSize        =    0;
  275.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  276. //    MyCaos.PPCStart        =    NULL;
  277. //    MyCaos.PPCSize        =    0;
  278.     MyCaos.a0        =(ULONG) cxm;
  279.     MyCaos.caos_Un.Offset    =    (-168);
  280.     MyCaos.a6        =(ULONG) CxBase;    
  281.     PPCCallOS(&MyCaos);
  282. }
  283.  
  284. #define    DivertCxMsg(cxm, headObj, returnObj)    _DivertCxMsg(COMMODITIES_BASE_NAME, cxm, headObj, returnObj)
  285.  
  286. static __inline void
  287. _DivertCxMsg(void *CxBase, CxMsg *cxm, CxObj *headObj, CxObj *returnObj)
  288. {
  289. struct Caos    MyCaos;
  290.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  291. //    MyCaos.M68kStart    =    NULL;
  292. //    MyCaos.M68kSize        =    0;
  293.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  294. //    MyCaos.PPCStart        =    NULL;
  295. //    MyCaos.PPCSize        =    0;
  296.     MyCaos.a0        =(ULONG) cxm;
  297.     MyCaos.a1        =(ULONG) headObj;
  298.     MyCaos.a2        =(ULONG) returnObj;
  299.     MyCaos.caos_Un.Offset    =    (-156);
  300.     MyCaos.a6        =(ULONG) CxBase;    
  301.     PPCCallOS(&MyCaos);
  302. }
  303.  
  304. #define    EnqueueCxObj(headObj, co)    _EnqueueCxObj(COMMODITIES_BASE_NAME, headObj, co)
  305.  
  306. static __inline void
  307. _EnqueueCxObj(void *CxBase, CxObj *headObj, CxObj *co)
  308. {
  309. struct Caos    MyCaos;
  310.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  311. //    MyCaos.M68kStart    =    NULL;
  312. //    MyCaos.M68kSize        =    0;
  313.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  314. //    MyCaos.PPCStart        =    NULL;
  315. //    MyCaos.PPCSize        =    0;
  316.     MyCaos.a0        =(ULONG) headObj;
  317.     MyCaos.a1        =(ULONG) co;
  318.     MyCaos.caos_Un.Offset    =    (-90);
  319.     MyCaos.a6        =(ULONG) CxBase;    
  320.     PPCCallOS(&MyCaos);
  321. }
  322.  
  323. #define    InsertCxObj(headObj, co, pred)    _InsertCxObj(COMMODITIES_BASE_NAME, headObj, co, pred)
  324.  
  325. static __inline void
  326. _InsertCxObj(void *CxBase, CxObj *headObj, CxObj *co, CxObj *pred)
  327. {
  328. struct Caos    MyCaos;
  329.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  330. //    MyCaos.M68kStart    =    NULL;
  331. //    MyCaos.M68kSize        =    0;
  332.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  333. //    MyCaos.PPCStart        =    NULL;
  334. //    MyCaos.PPCSize        =    0;
  335.     MyCaos.a0        =(ULONG) headObj;
  336.     MyCaos.a1        =(ULONG) co;
  337.     MyCaos.a2        =(ULONG) pred;
  338.     MyCaos.caos_Un.Offset    =    (-96);
  339.     MyCaos.a6        =(ULONG) CxBase;    
  340.     PPCCallOS(&MyCaos);
  341. }
  342.  
  343. #define    InvertKeyMap(ansiCode, event, km)    _InvertKeyMap(COMMODITIES_BASE_NAME, ansiCode, event, km)
  344.  
  345. static __inline BOOL
  346. _InvertKeyMap(void *CxBase, unsigned long ansiCode, struct InputEvent *event, struct KeyMap *km)
  347. {
  348. struct Caos    MyCaos;
  349.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  350. //    MyCaos.M68kStart    =    NULL;
  351. //    MyCaos.M68kSize        =    0;
  352.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  353. //    MyCaos.PPCStart        =    NULL;
  354. //    MyCaos.PPCSize        =    0;
  355.     MyCaos.d0        =(ULONG) ansiCode;
  356.     MyCaos.a0        =(ULONG) event;
  357.     MyCaos.a1        =(ULONG) km;
  358.     MyCaos.caos_Un.Offset    =    (-174);
  359.     MyCaos.a6        =(ULONG) CxBase;    
  360.     return((BOOL)PPCCallOS(&MyCaos));
  361. }
  362.  
  363. #define    MatchIX(event, ix)    _MatchIX(COMMODITIES_BASE_NAME, event, ix)
  364.  
  365. static __inline BOOL
  366. _MatchIX(void *CxBase, struct InputEvent *event, IX *ix)
  367. {
  368. struct Caos    MyCaos;
  369.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  370. //    MyCaos.M68kStart    =    NULL;
  371. //    MyCaos.M68kSize        =    0;
  372.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  373. //    MyCaos.PPCStart        =    NULL;
  374. //    MyCaos.PPCSize        =    0;
  375.     MyCaos.a0        =(ULONG) event;
  376.     MyCaos.a1        =(ULONG) ix;
  377.     MyCaos.caos_Un.Offset    =    (-204);
  378.     MyCaos.a6        =(ULONG) CxBase;    
  379.     return((BOOL)PPCCallOS(&MyCaos));
  380. }
  381.  
  382. #define    ParseIX(description, ix)    _ParseIX(COMMODITIES_BASE_NAME, description, ix)
  383.  
  384. static __inline LONG
  385. _ParseIX(void *CxBase, STRPTR description, IX *ix)
  386. {
  387. struct Caos    MyCaos;
  388.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  389. //    MyCaos.M68kStart    =    NULL;
  390. //    MyCaos.M68kSize        =    0;
  391.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  392. //    MyCaos.PPCStart        =    NULL;
  393. //    MyCaos.PPCSize        =    0;
  394.     MyCaos.a0        =(ULONG) description;
  395.     MyCaos.a1        =(ULONG) ix;
  396.     MyCaos.caos_Un.Offset    =    (-132);
  397.     MyCaos.a6        =(ULONG) CxBase;    
  398.     return((LONG)PPCCallOS(&MyCaos));
  399. }
  400.  
  401. #define    RemoveCxObj(co)    _RemoveCxObj(COMMODITIES_BASE_NAME, co)
  402.  
  403. static __inline void
  404. _RemoveCxObj(void *CxBase, CxObj *co)
  405. {
  406. struct Caos    MyCaos;
  407.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  408. //    MyCaos.M68kStart    =    NULL;
  409. //    MyCaos.M68kSize        =    0;
  410.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  411. //    MyCaos.PPCStart        =    NULL;
  412. //    MyCaos.PPCSize        =    0;
  413.     MyCaos.a0        =(ULONG) co;
  414.     MyCaos.caos_Un.Offset    =    (-102);
  415.     MyCaos.a6        =(ULONG) CxBase;    
  416.     PPCCallOS(&MyCaos);
  417. }
  418.  
  419. #define    RouteCxMsg(cxm, co)    _RouteCxMsg(COMMODITIES_BASE_NAME, cxm, co)
  420.  
  421. static __inline void
  422. _RouteCxMsg(void *CxBase, CxMsg *cxm, CxObj *co)
  423. {
  424. struct Caos    MyCaos;
  425.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  426. //    MyCaos.M68kStart    =    NULL;
  427. //    MyCaos.M68kSize        =    0;
  428.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  429. //    MyCaos.PPCStart        =    NULL;
  430. //    MyCaos.PPCSize        =    0;
  431.     MyCaos.a0        =(ULONG) cxm;
  432.     MyCaos.a1        =(ULONG) co;
  433.     MyCaos.caos_Un.Offset    =    (-162);
  434.     MyCaos.a6        =(ULONG) CxBase;    
  435.     PPCCallOS(&MyCaos);
  436. }
  437.  
  438. #define    SetCxObjPri(co, pri)    _SetCxObjPri(COMMODITIES_BASE_NAME, co, pri)
  439.  
  440. static __inline LONG
  441. _SetCxObjPri(void *CxBase, CxObj *co, long pri)
  442. {
  443. struct Caos    MyCaos;
  444.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  445. //    MyCaos.M68kStart    =    NULL;
  446. //    MyCaos.M68kSize        =    0;
  447.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  448. //    MyCaos.PPCStart        =    NULL;
  449. //    MyCaos.PPCSize        =    0;
  450.     MyCaos.a0        =(ULONG) co;
  451.     MyCaos.d0        =(ULONG) pri;
  452.     MyCaos.caos_Un.Offset    =    (-78);
  453.     MyCaos.a6        =(ULONG) CxBase;    
  454.     return((LONG)PPCCallOS(&MyCaos));
  455. }
  456.  
  457. #define    SetFilter(filter, text)    _SetFilter(COMMODITIES_BASE_NAME, filter, text)
  458.  
  459. static __inline void
  460. _SetFilter(void *CxBase, CxObj *filter, STRPTR text)
  461. {
  462. struct Caos    MyCaos;
  463.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  464. //    MyCaos.M68kStart    =    NULL;
  465. //    MyCaos.M68kSize        =    0;
  466.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  467. //    MyCaos.PPCStart        =    NULL;
  468. //    MyCaos.PPCSize        =    0;
  469.     MyCaos.a0        =(ULONG) filter;
  470.     MyCaos.a1        =(ULONG) text;
  471.     MyCaos.caos_Un.Offset    =    (-120);
  472.     MyCaos.a6        =(ULONG) CxBase;    
  473.     PPCCallOS(&MyCaos);
  474. }
  475.  
  476. #define    SetFilterIX(filter, ix)    _SetFilterIX(COMMODITIES_BASE_NAME, filter, ix)
  477.  
  478. static __inline void
  479. _SetFilterIX(void *CxBase, CxObj *filter, IX *ix)
  480. {
  481. struct Caos    MyCaos;
  482.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  483. //    MyCaos.M68kStart    =    NULL;
  484. //    MyCaos.M68kSize        =    0;
  485.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  486. //    MyCaos.PPCStart        =    NULL;
  487. //    MyCaos.PPCSize        =    0;
  488.     MyCaos.a0        =(ULONG) filter;
  489.     MyCaos.a1        =(ULONG) ix;
  490.     MyCaos.caos_Un.Offset    =    (-126);
  491.     MyCaos.a6        =(ULONG) CxBase;    
  492.     PPCCallOS(&MyCaos);
  493. }
  494.  
  495. #define    SetTranslate(translator, events)    _SetTranslate(COMMODITIES_BASE_NAME, translator, events)
  496.  
  497. static __inline void
  498. _SetTranslate(void *CxBase, CxObj *translator, struct InputEvent *events)
  499. {
  500. struct Caos    MyCaos;
  501.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  502. //    MyCaos.M68kStart    =    NULL;
  503. //    MyCaos.M68kSize        =    0;
  504.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  505. //    MyCaos.PPCStart        =    NULL;
  506. //    MyCaos.PPCSize        =    0;
  507.     MyCaos.a0        =(ULONG) translator;
  508.     MyCaos.a1        =(ULONG) events;
  509.     MyCaos.caos_Un.Offset    =    (-114);
  510.     MyCaos.a6        =(ULONG) CxBase;    
  511.     PPCCallOS(&MyCaos);
  512. }
  513.  
  514. #endif /* SASC Pragmas */
  515. #endif /* !_PPCPRAGMA_COMMODITIES_H */
  516.